home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / exampleCode / inventor / noodle / Interface.c++ < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  31.2 KB  |  1,066 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  |   Classes:
  19.  |    Interface
  20.  |
  21.  |   Author(s): Paul Isaacs
  22.  |
  23.  */
  24.  
  25.  
  26. #include <stdio.h>
  27. #include <Inventor/SbLinear.h>
  28. #include <Inventor/SoDB.h>
  29.  
  30. #include <Xm/MessageB.h>
  31.  
  32. #include <Inventor/actions/SoBoxHighlightRenderAction.h>
  33. #include <Inventor/actions/SoWriteAction.h>
  34. #include <Inventor/manips/SoHandleBoxManip.h>
  35. #include <Inventor/manips/SoTrackballManip.h>
  36. #include <Inventor/nodes/SoSelection.h>
  37. #include <Inventor/nodes/SoSeparator.h>
  38. #include <Inventor/Xt/SoXt.h>
  39. #include <Inventor/Xt/SoXtClipboard.h>
  40. #include <Inventor/Xt/viewers/SoXtViewer.h>
  41.  
  42. #include "GeneralizedCylinder.h"
  43. #include "WorldInfo.h"
  44. #include "PullDowns.h"
  45. #include "Interface.h"
  46. #include "NoodleTextureGizmo.h"
  47. #include "NoodleSurfaceGizmo.h"
  48.  
  49. extern SoNode *createProfileGraph( Widget, GeneralizedCylinder *);
  50. extern SoNode *createCrossSectionGraph( Widget, GeneralizedCylinder *);
  51. extern SoNode *createSpineGraph( Widget, GeneralizedCylinder *);
  52. extern SoNode *createTwistGraph( Widget, GeneralizedCylinder *);
  53.  
  54. Interface::Interface()
  55. {
  56.     // Initialize other variables.
  57.     bgColor.setValue(0,0,0);
  58.     worldInfo = NULL;
  59.     mgrWidget = NULL;
  60.     mainViewer = NULL;
  61.     menuItems = NULL;
  62.     myTextureGizmo = NULL;
  63.     mySurfaceGizmo = NULL;
  64.  
  65.     profileViewer = NULL;
  66.     sectionViewer = NULL;
  67.     spineViewer = NULL;
  68.     twistViewer = NULL;
  69.  
  70.     closeProfileButton = NULL;
  71.     closeSectionButton = NULL;
  72.     closeSpineButton = NULL;
  73.     closeTwistButton = NULL;
  74. }
  75.  
  76. Interface::~Interface()
  77. {
  78.     worldInfo = NULL;
  79.     if (myTextureGizmo)
  80.     delete myTextureGizmo;
  81.     if (mySurfaceGizmo)
  82.     delete mySurfaceGizmo;
  83. }
  84.  
  85. void       
  86. Interface::setWorldInfo( WorldInfo *newWorldInfo )
  87. {
  88.     if (newWorldInfo == NULL)
  89.     return;
  90.  
  91.     worldInfo = newWorldInfo;
  92.     SoSelection *s = worldInfo->getSelectorNode();
  93.     s->addSelectionCallback( &Interface::selectionCB, this );
  94. }
  95.  
  96. /////////////////////////////////////////////////////////////////////
  97. // Reads the scene given by filename and puts the results into worldInfo.
  98. // Returns pointer to top of scene graph.
  99. // If filename is NULL, uses name already found in worldInfo.
  100. // If filename and worldInfo are both NULL, it is an error.
  101. SoSeparator * 
  102. Interface::readScene( char *newFileName, SbBool okIfNoName )
  103. {
  104.     if (newFileName == NULL && 
  105.     (worldInfo == NULL || worldInfo->getFileName() == NULL)) {
  106.     if ( ! okIfNoName ) {
  107.         fprintf(stderr, "Interface::readScene programming error:"
  108.                 "Can\'t read scene because no filename given and \n"
  109.                 "Interface has worldInfo equal to NULL\n");
  110.     }
  111.     return (NULL);
  112.     }
  113.  
  114.     SoInput in;
  115.     SoSeparator *root;
  116.     FILE *filePtr = NULL;
  117.     char cmd[250];
  118.     
  119.     if (newFileName != NULL && worldInfo != NULL)
  120.     worldInfo->setFileName( newFileName );
  121.  
  122.     const char *fName 
  123.         = (worldInfo == NULL) ? newFileName : worldInfo->getFileName();
  124.  
  125.     fprintf(stderr, "Reading file %s...\n", fName );
  126.  
  127.     const char *slashPtr;
  128.     char *searchPath = NULL;
  129.  
  130.     filePtr = fopen(fName, "r");
  131.     if (filePtr == NULL) {
  132.     fprintf(stderr, "Error opening file %s\n", fName);
  133.     return (NULL);
  134.     }
  135.  
  136.     //
  137.     // If the filename includes a directory path, add the 
  138.     // directory name to the list of directories where to look
  139.     // for files referenced in the input file (e.g. SoFile nodes)
  140.     //
  141.     if ((slashPtr = strrchr(fName, '/')) != NULL) {
  142.     searchPath = strdup(fName);
  143.     searchPath[slashPtr - fName] = '\0';
  144.     in.addDirectoryFirst(searchPath);
  145.     }
  146.  
  147.     in.setFilePointer(filePtr);
  148.     root = SoDB::readAll(&in);
  149.     if (root == NULL) 
  150.     fprintf(stderr, "Error reading file %s\n", fName);
  151.  
  152.     fclose(filePtr);
  153.     if ( worldInfo != NULL)
  154.     worldInfo->setScene( root );
  155.     return root;
  156. }
  157.  
  158. /////////////////////////////////////////////////////////////////////
  159. // Writes the scene contained in worldInfo.
  160. // If asVanilla==FALSE, uses special GeneralizedCylinder class in the file. 
  161. // If asVanilla==TRUE, uses only standard Inventor nodes.
  162. // If filename is NULL, uses name already found in worldInfo.
  163. // If filename and worldInfo->getFileName() are both NULL, it is an error.
  164. void 
  165. Interface::writeToFile( SbBool asVanilla, char *newFileName )
  166. {
  167.     if ( worldInfo == NULL ||
  168.     (newFileName == NULL && worldInfo->getFileName() == NULL)) {
  169.     fprintf(stderr, "Interface::writeToFile programming error:"
  170.             "Can\'t write scene because no filename given or \n"
  171.             "Interface has worldInfo equal to NULL\n");
  172.     return;
  173.     }
  174.  
  175.     SoWriteAction   wa;
  176.  
  177.     if (newFileName != NULL )
  178.     worldInfo->setFileName( newFileName );
  179.  
  180.     const char *fName = worldInfo->getFileName();
  181.  
  182.     if (! wa.getOutput()->openFile(fName)) {
  183.     char str[100];
  184.     strcpy(str, "Error creating file: ");
  185.     strcat(str, fName);
  186.     SoXt::createSimpleErrorDialog(mgrWidget, 
  187.                       "File Write Error Dialog", str);
  188.     }
  189.     else {
  190.     // Temporarily remove manips from scene
  191.     SoType savedManipType = worldInfo->getManipType();
  192.     worldInfo->setManipType( SoTransform::getClassTypeId() );
  193.  
  194.     // Get the scene from worldInfo and write it out.
  195.     SoSeparator *scene;
  196.     if ( asVanilla )
  197.         scene = worldInfo->getVanillaSceneCopy();
  198.     else
  199.         scene = worldInfo->getScene();
  200.  
  201.  
  202.     scene->ref();
  203.     wa.apply(scene);
  204.     wa.getOutput()->closeFile();
  205.     scene->unref();
  206.  
  207.     // Restore manips to scene.
  208.     worldInfo->setManipType( savedManipType );
  209.     }
  210. }
  211.  
  212. ///////////////////////////////////////////////////////////////////
  213. //
  214. // If scene isn't empty, check if user wants to save scene first.
  215. // If not, then create an empty scene so user can start over.
  216. //
  217. void 
  218. Interface::fileNewEvent()
  219. {
  220.     if (worldInfo->isSceneEmpty() == FALSE ) {
  221.     createOkayCancelDialog(mgrWidget, 
  222.         Interface::newSceneCB,
  223.         "New Scene Error Dialog",
  224.         "Your current scene is not empty.",
  225.         "Hit OK to continue, CANCEL if you want to Save first.");
  226.  
  227.     }
  228.     else
  229.     Interface::newSceneCB(NULL, (XtPointer) this, NULL);
  230. }
  231.  
  232. ///////////////////////////////////////////////////////////////////
  233. //
  234. // If scene not empty, check if user wants to save scene first.
  235. // If not, bring up the file dialog box and read a new scene from file.
  236. //
  237. void 
  238. Interface::fileOpenEvent()
  239. {
  240.     if (worldInfo->isSceneEmpty() == FALSE ) {
  241.     createOkayCancelDialog(mgrWidget, 
  242.         Interface::openSceneCB,
  243.         "Open Scene Error Dialog",
  244.         "Your current scene is not empty.",
  245.         "Hit OK to continue, CANCEL if you want to Save first.");
  246.  
  247.     }
  248.     else
  249.     Interface::openSceneCB(NULL, (XtPointer) this, NULL);
  250. }
  251.  
  252. ///////////////////////////////////////////////////////////////////
  253. //
  254. // If scene is empty, show a dialog and return.
  255. // If there is more than one file in the list, direct them to Save As...
  256. // If everything's okay, ask the world for the scene and write it out.
  257. //
  258. void 
  259. Interface::fileSaveEvent()
  260. {
  261.     if (worldInfo->isSceneEmpty() == TRUE ) {
  262.     SoXt::createSimpleErrorDialog(mgrWidget, 
  263.         "File Save Empty Error Dialog",
  264.         "The current scene is empty. Create a scene first,",
  265.         "or fix my code to grey out this menu item.");
  266.     }
  267.     else
  268.     writeToFile( FALSE );
  269. }
  270.  
  271. ///////////////////////////////////////////////////////////////////
  272. //
  273. // If the scene is empty, show a dialog and return.
  274. // If everything's okay, ask the world for the scene and write it out.
  275. //
  276. void 
  277. Interface::fileSaveAsEvent()
  278. {
  279.     if (worldInfo->isSceneEmpty() == TRUE ) {
  280.     SoXt::createSimpleErrorDialog(mgrWidget, 
  281.         "File Save As Empty Error Dialog",
  282.         "The current scene is empty. Create a scene first,",
  283.         "or fix my code to grey out this menu item.");
  284.     }
  285.     else
  286.     showFileSelectionDialog( (XtCallbackProc) Interface::writeToFileCB );
  287. }
  288.  
  289. ///////////////////////////////////////////////////////////////////
  290. //
  291. // If the scene is empty, show a dialog and return.
  292. // If everything's okay, ask the world for the scene and write it out.
  293. //
  294. void 
  295. Interface::fileSaveVanillaEvent()
  296. {
  297.     if (worldInfo->isSceneEmpty() == TRUE ) {
  298.     SoXt::createSimpleErrorDialog(mgrWidget, 
  299.         "File Save As Empty Error Dialog",
  300.         "The current scene is empty. Create a scene first,",
  301.         "or fix my code to grey out this menu item.");
  302.     }
  303.     else
  304.     showFileSelectionDialog( (XtCallbackProc) Interface::writeToVanillaFileCB );
  305. }
  306.  
  307. ///////////////////////////////////////////////////////////////////
  308. //
  309. // If the scene is not empty, see if the user would like to save.
  310. // Otherwise, quit.
  311. //
  312. void 
  313. Interface::fileQuitEvent()
  314. {
  315.     if (worldInfo->isSceneEmpty() == FALSE ) {
  316.     createOkayCancelDialog(mgrWidget, 
  317.         Interface::quitProgramCB,
  318.         "Quit Error Dialog",
  319.         "Your current scene is not empty.",
  320.         "Hit OK to Quit anyway, CANCEL if you want to Save first.");
  321.  
  322.     }
  323.     else
  324.     Interface::quitProgramCB(NULL, (XtPointer) this, NULL);
  325. }
  326.  
  327. ////////////////////////////////////////////////////////////////////////
  328. //
  329. // creates a dialog box.
  330. // Prints a message and has two buttons:
  331. // CANCEL and OK.
  332. //
  333. // When calling this, you must pass a callback for when the 
  334. // OK button is pressed.
  335. //
  336. void
  337. Interface::createOkayCancelDialog(Widget widget, XtCallbackProc okCB,
  338.     char *dialogTitle, char *str1, char *str2)
  339. {
  340.     Widget shell = SoXt::getShellWidget(widget);
  341.     if (shell == NULL)
  342.     return;
  343.     
  344.     Arg args[5];
  345.     XmString xmstr = XmStringCreateSimple(str1);
  346.     xmstr = XmStringConcat(xmstr, XmStringSeparatorCreate());
  347.     xmstr = XmStringConcat(xmstr, XmStringCreateSimple(str2));
  348.     
  349.     int n = 0;
  350.     XtSetArg(args[n], XmNautoUnmanage, FALSE); n++;
  351.     XtSetArg(args[n], XtNtitle, dialogTitle); n++;
  352.     XtSetArg(args[n], XmNmessageString, xmstr); n++;
  353.     Widget dialog = XmCreateErrorDialog(shell, "Error Dialog", args, n);
  354.     XmStringFree(xmstr);
  355.     
  356.     XtUnmanageChild(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
  357.     
  358.     // First, destroy the dialog box.
  359.     // Then, call the passed callback.
  360.     XtAddCallback(dialog, XmNokCallback, 
  361.     (XtCallbackProc) Interface::destroyDialogCB, (XtPointer)this);
  362.     XtAddCallback(dialog, XmNokCallback, 
  363.     (XtCallbackProc) okCB, (XtPointer)this);
  364.  
  365.     // If the user cancels, we'll always want to destroy the dialog.
  366.     // register callback to destroy (and not just unmap) the dialog
  367.     XtAddCallback(dialog, XmNcancelCallback, 
  368.     (XtCallbackProc) Interface::destroyDialogCB, (XtPointer)this);
  369.     
  370.     XtManageChild(dialog);
  371. }
  372.  
  373. ///////////////////////////////////////////////////////////////////
  374. //
  375. // Brings up the "About..." dialog
  376. //
  377. void
  378. Interface::showAboutDialog()
  379. {
  380.    if (access("noodle.about", R_OK) != 0) {
  381.         system("xconfirm -t 'Sorry, could not find "
  382.                "noodle.about' > /dev/null");
  383.         return;
  384.     }
  385.  
  386.     char command[100];
  387.     sprintf(command, "showcase -v noodle.about");
  388.  
  389.     int err = system(command);
  390.     if (err) {
  391.         system("xconfirm -t 'You must install showcase"
  392.                " for this function to work' > /dev/null");
  393.         return;
  394.     }
  395. }
  396.  
  397. ///////////////////////////////////////////////////////////////////
  398. //
  399. // Use a motif file selection dialog to get the new filename.  
  400. // When calling this, you must pass a callback for when the 
  401. // OK button is pressed.
  402. //
  403. void
  404. Interface::showFileSelectionDialog( XtCallbackProc okCB )
  405. {
  406.     static Widget fileDialog = NULL;
  407.  
  408.     if (fileDialog == NULL) {
  409.         Arg args[5];
  410.         int n = 0;
  411.  
  412.         // Unmanage when ok/cancel are pressed
  413.         XtSetArg(args[n], XmNautoUnmanage, TRUE); n++;
  414.         fileDialog = XmCreateFileSelectionDialog(
  415.             XtParent(mgrWidget), "File Dialog", args, n);
  416.  
  417.         XtAddCallback(fileDialog, XmNokCallback,
  418.                       (XtCallbackProc)okCB, (XtPointer) this);
  419.     }
  420.     else {
  421.     // We need to remove the old callback, 
  422.     // then install the one we were passed, since this file selector
  423.     // is used for both reading and writing files.
  424.         XtRemoveAllCallbacks(fileDialog, XmNokCallback );
  425.         XtAddCallback(fileDialog, XmNokCallback,
  426.                       (XtCallbackProc)okCB, this);
  427.     }
  428.  
  429.     // Manage the dialog
  430.     XtManageChild(fileDialog);
  431. }
  432.  
  433.  
  434. //////////////////////////////////////////////////////////////
  435. // Gets rid of dialog box.
  436. void 
  437. Interface::destroyDialogCB(Widget dialog, void *, void *)
  438. { 
  439.     XtDestroyWidget(dialog); 
  440. }
  441.  
  442. //////////////////////////////////////////////////////////////
  443. // Makes a brand new scene.
  444. //
  445. void 
  446. Interface::newSceneCB(Widget, void *userData, void *)
  447. {
  448.     ((Interface *) userData)->getWorldInfo()->setScene( new SoSeparator );
  449. }
  450.  
  451. //////////////////////////////////////////////////////////////
  452. // Brings up file selection widget and reads scene from selected file.
  453. //
  454. void 
  455. Interface::openSceneCB(Widget, void *userData, void *)
  456. {
  457.     ((Interface *)userData)->showFileSelectionDialog( 
  458.                 (XtCallbackProc) Interface::readFromFileCB );
  459. }
  460.  
  461. //////////////////////////////////////////////////////////////
  462. // Brings up file selection widget and reads scene from selected file.
  463. // Callback routine that gets called when the new filename
  464. // has been entered. 
  465. //
  466. // Reads the scene and gives it to 'worldInfo'
  467. //
  468. void
  469. Interface::readFromFileCB(Widget, void *userData, 
  470.               XmFileSelectionBoxCallbackStruct *data)
  471. {
  472.     // Get the file name
  473.     char *filename;
  474.     XmStringGetLtoR(data->value,
  475.         (XmStringCharSet) XmSTRING_DEFAULT_CHARSET, &filename);
  476.    
  477.     ((Interface *)userData)->readScene( filename );
  478.  
  479.     XtFree(filename);
  480. }
  481.  
  482. //////////////////////////////////////////////////////////////
  483. // Callback routine that gets called when the new filename
  484. // has been entered. 
  485. //
  486. // Writes the scene held by 'worldInfo'
  487. //
  488. void
  489. Interface::writeToFileCB(Widget, void *userData, 
  490.             XmFileSelectionBoxCallbackStruct *data)
  491. {
  492.     // Get the file name
  493.     char *filename;
  494.     XmStringGetLtoR(data->value,
  495.         (XmStringCharSet) XmSTRING_DEFAULT_CHARSET, &filename);
  496.  
  497.     ((Interface *)userData)->writeToFile( FALSE, filename );
  498.  
  499.     XtFree(filename);
  500. }
  501.  
  502. //////////////////////////////////////////////////////////////
  503. // Callback routine that gets called when the new filename
  504. // has been entered. 
  505. //
  506. // Writes the scene AS A STANDARD INVENTOR FILE WITHOUT GENERALIZED CYLINDERS
  507. // to file held by 'worldInfo'
  508. //
  509. void
  510. Interface::writeToVanillaFileCB(Widget, void *userData, 
  511.                 XmFileSelectionBoxCallbackStruct *data)
  512. {
  513.     // Get the file name
  514.     char *filename;
  515.     XmStringGetLtoR(data->value,
  516.         (XmStringCharSet) XmSTRING_DEFAULT_CHARSET, &filename);
  517.  
  518.     // TRUE means to write it 'vanilla style'
  519.     ((Interface *) userData)->writeToFile( TRUE, filename );
  520.    
  521.     XtFree(filename);
  522. }
  523.  
  524. void 
  525. Interface::quitProgramCB(Widget, void *, void *)
  526. {
  527.     exit(0);
  528. }
  529.  
  530. ///////////////////////////////////////////////////////////////////
  531. //
  532. // Process the topbar menu events.
  533. void
  534. Interface::processTopbarEvent(Widget, 
  535.               NoodleMenuItem *data, XmAnyCallbackStruct *cbstruct )
  536. {
  537.     Interface *myself = data->ownerInterface;
  538.     WorldInfo *myWorld = myself->worldInfo;
  539.     GeneralizedCylinder *myNoodle = myWorld->getCurrentNoodle();
  540.  
  541.     static SoXtClipboard *theClipboard = NULL;
  542.  
  543.     switch (data->id) {
  544.  
  545.     //
  546.     // File
  547.     //
  548.  
  549.     case MM_FILE_NEW:
  550.     myself->fileNewEvent();
  551.     break;
  552.  
  553.     case MM_FILE_OPEN:
  554.     myself->fileOpenEvent();
  555.     break;
  556.  
  557.     case MM_FILE_SAVE:
  558.     myself->fileSaveEvent();
  559.     break;
  560.  
  561.     case MM_FILE_SAVE_AS:
  562.     myself->fileSaveAsEvent();
  563.     break;
  564.  
  565.     case MM_FILE_SAVE_VANILLA:
  566.     myself->fileSaveVanillaEvent();
  567.     break;
  568.  
  569.     case MM_FILE_QUIT:
  570.     myself->fileQuitEvent();
  571.     break;    
  572.  
  573.     //
  574.     // Edit
  575.     //
  576.   
  577.     case MM_EDIT_NEW:
  578.     // Add the current selection to the list of deleted objects.
  579.     myWorld->addNewNoodle(); 
  580.     break;
  581.  
  582.     case MM_EDIT_DELETE:
  583.     // Add the current selection to the list of deleted objects.
  584.     myWorld->deleteCurrentNoodle();
  585.         // Set the primary selection to NULL...
  586.     myself->setPrimarySelection(NULL);
  587.     break;
  588.  
  589.     case MM_EDIT_UNDELETE:
  590.     // Undelete the most recently deleted object.
  591.     myWorld->undeleteNoodle();
  592.     break;
  593.  
  594.     case MM_EDIT_COPY:
  595.     case MM_EDIT_COPY_ALL:
  596.     // Establish what we are copying
  597.         SoNode *copyStuff;
  598.         if (data->id == MM_EDIT_COPY)
  599.         copyStuff = myNoodle;
  600.         else
  601.         copyStuff = myWorld->getScene();
  602.  
  603.     // Make a clipboard
  604.         if (theClipboard == NULL)
  605.         theClipboard = new SoXtClipboard(myself->mainViewer->getWidget());
  606.  
  607.     // Copy into clipboard
  608.         if ( copyStuff != NULL )
  609.         theClipboard->copy( copyStuff, cbstruct->event->xbutton.time);
  610.     break;
  611.  
  612.     //
  613.     // Options
  614.     //
  615.   
  616.     case MM_SHAPE_FACE_SET:
  617.     if ( myNoodle && XmToggleButtonGetState( data->widget ) ) {
  618.         myNoodle->renderShapeType = GeneralizedCylinder::FACE_SET;
  619.         myself->setRenderStyleRadioButtons( GeneralizedCylinder::FACE_SET );
  620.     }
  621.     break;
  622.     case MM_SHAPE_TRI_STRIP:
  623.     if ( myNoodle && XmToggleButtonGetState( data->widget ) ) {
  624.         myNoodle->renderShapeType = GeneralizedCylinder::TRIANGLE_STRIP_SET;
  625.         myself->setRenderStyleRadioButtons(GeneralizedCylinder::TRIANGLE_STRIP_SET);
  626.     }
  627.     break;
  628.     case MM_SHAPE_QUAD_MESH:
  629.     if ( myNoodle && XmToggleButtonGetState( data->widget ) ) {
  630.         myNoodle->renderShapeType = GeneralizedCylinder::QUAD_MESH;
  631.         myself->setRenderStyleRadioButtons(GeneralizedCylinder::QUAD_MESH);
  632.     }
  633.     break;
  634.     case MM_SHAPE_CUBIC_SPLINE:
  635.     if ( myNoodle && XmToggleButtonGetState( data->widget ) ) {
  636.         myNoodle->renderShapeType = GeneralizedCylinder::CUBIC_SPLINE_SURFACE;
  637.         myself->setRenderStyleRadioButtons(GeneralizedCylinder::CUBIC_SPLINE_SURFACE);
  638.     }
  639.     break;
  640.     case MM_SHAPE_CUBIC_TO_EDGE:
  641.     if ( myNoodle && XmToggleButtonGetState( data->widget ) ) {
  642.         myNoodle->renderShapeType = GeneralizedCylinder::CUBIC_TO_EDGE_SURFACE;
  643.         myself->setRenderStyleRadioButtons(GeneralizedCylinder::CUBIC_TO_EDGE_SURFACE);
  644.     }
  645.     break;
  646.     case MM_SHAPE_BEZIER:
  647.     if ( myNoodle && XmToggleButtonGetState( data->widget ) ) {
  648.         myNoodle->renderShapeType = GeneralizedCylinder::BEZIER_SURFACE;
  649.         myself->setRenderStyleRadioButtons(GeneralizedCylinder::BEZIER_SURFACE);
  650.     }
  651.     break;
  652.  
  653.     case MM_PARTS_SIDES:
  654.     if (myNoodle  != NULL ) {
  655.         GeneralizedCylinder *c = myNoodle;
  656.         if (c->withSides.getValue())
  657.         c->withSides = FALSE;
  658.         else
  659.         c->withSides = TRUE;
  660.     }
  661.     break;
  662.     case MM_PARTS_TOP_CAP:
  663.     if (myNoodle  != NULL ) {
  664.         GeneralizedCylinder *c = myNoodle;
  665.         if (c->withTopCap.getValue())
  666.         c->withTopCap = FALSE;
  667.         else
  668.         c->withTopCap = TRUE;
  669.     }
  670.     break;
  671.     case MM_PARTS_BOT_CAP:
  672.     if (myNoodle  != NULL ) {
  673.         GeneralizedCylinder *c = myNoodle;
  674.         if (c->withBottomCap.getValue())
  675.         c->withBottomCap = FALSE;
  676.         else
  677.         c->withBottomCap = TRUE;
  678.     }
  679.     break;
  680.  
  681.     //
  682.     // Manips
  683.     //
  684.     case MM_MANIPS_HBOX:
  685.     if ( XmToggleButtonGetState( data->widget ) ) {
  686.         if (myWorld->getManipType() != SoHandleBoxManip::getClassTypeId()) {
  687.  
  688.         // Don't show bounding box (check action type to be safe...)
  689.         SoGLRenderAction *ra = myself->mainViewer->getGLRenderAction();
  690.         if (ra->isOfType( SoBoxHighlightRenderAction::getClassTypeId()))
  691.             ((SoBoxHighlightRenderAction *) ra)->setVisible(FALSE);
  692.  
  693.         myWorld->setManipType( SoHandleBoxManip::getClassTypeId() );
  694.             myself->setManipTypeRadioButtons( SoHandleBoxManip::getClassTypeId() );
  695.         }
  696.     }
  697.     break;
  698.     case MM_MANIPS_TRACKBALL:
  699.     if ( XmToggleButtonGetState( data->widget ) ) {
  700.         if (myWorld->getManipType() != SoTrackballManip::getClassTypeId()) {
  701.  
  702.         // Don't show bounding box (check action type to be safe...)
  703.         SoGLRenderAction *ra = myself->mainViewer->getGLRenderAction();
  704.         if (ra->isOfType( SoBoxHighlightRenderAction::getClassTypeId()))
  705.             ((SoBoxHighlightRenderAction *) ra)->setVisible(FALSE);
  706.  
  707.         myWorld->setManipType( SoTrackballManip::getClassTypeId() );
  708.             myself->setManipTypeRadioButtons( SoTrackballManip::getClassTypeId() );
  709.         }
  710.     }
  711.     break;
  712.     case MM_MANIPS_NONE:
  713.     if ( XmToggleButtonGetState( data->widget ) ) {
  714.         if (myWorld->getManipType() != SoTransform::getClassTypeId() ) {
  715.  
  716.         // Do show bounding box (check renderaction type to be safe...)
  717.         SoGLRenderAction *ra = myself->mainViewer->getGLRenderAction();
  718.         if (ra->isOfType( SoBoxHighlightRenderAction::getClassTypeId()))
  719.             ((SoBoxHighlightRenderAction *) ra)->setVisible(TRUE);
  720.  
  721.         myWorld->setManipType( SoTransform::getClassTypeId() );
  722.             myself->setManipTypeRadioButtons( SoTransform::getClassTypeId() );
  723.         }
  724.     }
  725.     break;
  726.  
  727.     case MM_GIZMOS_TEXTURE:
  728.     {
  729.         // Create a texture gizmo, if it does not exist.
  730.         if (myself->myTextureGizmo == NULL ) {
  731.             myself->myTextureGizmo = new NoodleTextureGizmo();
  732.         myself->myTextureGizmo->setTitle( "Texture Gizmo" );
  733.             // Set the noodle for the gizmo.
  734.         myself->myTextureGizmo->setNoodle( myNoodle ); 
  735.         }
  736.         // Show the texture gizmo. 
  737.         myself->myTextureGizmo->show();
  738.     }
  739.     break;
  740.  
  741.     case MM_GIZMOS_SURFACE:
  742.     {
  743.         if (myself->mySurfaceGizmo == NULL ) {
  744.             // Create a surface gizmo, if it does not exist.
  745.             myself->mySurfaceGizmo = new NoodleSurfaceGizmo();
  746.         myself->mySurfaceGizmo->setTitle( "Surface Gizmo" );
  747.             // Set the noodle for the gizmo.
  748.         myself->mySurfaceGizmo->setNoodle( myNoodle ); 
  749.         }
  750.         // Show the surface gizmo. 
  751.         myself->mySurfaceGizmo->show();
  752.     }
  753.     break;
  754.  
  755.     // 
  756.     // About
  757.     // 
  758.     case MM_ABOUT_ABOUT:
  759.      myself->showAboutDialog();
  760.     break;
  761.  
  762.     } 
  763. }
  764.  
  765. ///////////////////////////////////////////////////////////////////
  766. //
  767. // Makes all settings of the interface reflect the given object
  768. void
  769. Interface::setPrimarySelection( GeneralizedCylinder *g )
  770. {
  771.     if (menuItems == NULL)
  772.     return;
  773.  
  774.     SbBool bv;
  775.  
  776.     // Render Style:
  777.     if (g == NULL)
  778.         setRenderStyleRadioButtons( GeneralizedCylinder::FACE_SET );
  779.     else
  780.         setRenderStyleRadioButtons( (GeneralizedCylinder::RenderShapeType) 
  781.                      g->renderShapeType.getValue());
  782.  
  783.     // Parts on or off:
  784.     bv = (g) ? g->withSides.getValue() : FALSE; 
  785.     XmToggleButtonSetState( menuItems[MM_PARTS_SIDES].widget,bv,FALSE);
  786.     bv = (g) ? g->withTopCap.getValue() : FALSE; 
  787.     XmToggleButtonSetState( menuItems[MM_PARTS_TOP_CAP].widget,bv,FALSE);
  788.     bv = (g) ? g->withBottomCap.getValue() : FALSE; 
  789.     XmToggleButtonSetState( menuItems[MM_PARTS_BOT_CAP].widget,bv,FALSE);
  790.  
  791.     // Manip Type:
  792.     SoNode *xf = NULL;
  793.     if ( g )
  794.         xf = g->getPart( "transform", FALSE );
  795.     if ( ! xf )
  796.         setManipTypeRadioButtons( SoTransform::getClassTypeId() );
  797.     else
  798.         setManipTypeRadioButtons( xf->getTypeId() );
  799.  
  800.     // Texture
  801.     if (myTextureGizmo)
  802.         myTextureGizmo->setNoodle( g );
  803.  
  804.     // Surface
  805.     if (mySurfaceGizmo)
  806.         mySurfaceGizmo->setNoodle( g );
  807.  
  808.     // Tell the curve viewers to build new scenes...
  809.     if (profileViewer)
  810.         profileViewer->setSceneGraph(
  811.         createProfileGraph(profileViewer->getWidget(), g));
  812.     if (sectionViewer)
  813.         sectionViewer->setSceneGraph(
  814.         createCrossSectionGraph(sectionViewer->getWidget(),g));
  815.     if (spineViewer)
  816.         spineViewer->setSceneGraph(
  817.         createSpineGraph(spineViewer->getWidget(), g));
  818.     if (twistViewer)
  819.         twistViewer->setSceneGraph(
  820.         createTwistGraph(twistViewer->getWidget(), g));
  821.  
  822.     // Curve information for each of the four editors...
  823.     bv = (g) ? g->profileClosed.getValue() : FALSE;
  824.     XmToggleButtonSetState(closeProfileButton, bv, FALSE );
  825.     bv = (g) ? g->crossSectionClosed.getValue() : FALSE;
  826.     XmToggleButtonSetState(closeSectionButton, bv, FALSE );
  827.     bv = (g) ? g->spineClosed.getValue() : FALSE;
  828.     XmToggleButtonSetState(closeSpineButton,  bv, FALSE );
  829.     bv = (g) ? g->twistClosed.getValue() : FALSE;
  830.     XmToggleButtonSetState(closeTwistButton, bv, FALSE );
  831.  
  832. }
  833.  
  834. void
  835. Interface::setRenderStyleRadioButtons( GeneralizedCylinder::RenderShapeType shapeType )
  836. {
  837.     // First turn all radio buttons to FALSE...
  838.     XmToggleButtonSetState(menuItems[MM_SHAPE_FACE_SET].widget,FALSE,FALSE);
  839.     XmToggleButtonSetState(menuItems[MM_SHAPE_TRI_STRIP].widget,FALSE,FALSE);
  840.     XmToggleButtonSetState(menuItems[MM_SHAPE_QUAD_MESH].widget,FALSE,FALSE);
  841.     XmToggleButtonSetState(menuItems[MM_SHAPE_CUBIC_SPLINE].widget,FALSE,FALSE);
  842.     XmToggleButtonSetState(menuItems[MM_SHAPE_CUBIC_TO_EDGE].widget,FALSE,FALSE);
  843.     XmToggleButtonSetState(menuItems[MM_SHAPE_BEZIER].widget,FALSE,FALSE);
  844.  
  845.     // Set the appropriate radio button for shape rendering type.
  846.     Widget onWidget = NULL;
  847.     switch(shapeType) {
  848.     case GeneralizedCylinder::FACE_SET:
  849.         onWidget = menuItems[MM_SHAPE_FACE_SET].widget;
  850.         break;
  851.     case GeneralizedCylinder::TRIANGLE_STRIP_SET:
  852.         onWidget = menuItems[MM_SHAPE_TRI_STRIP].widget;
  853.         break;
  854.     case GeneralizedCylinder::QUAD_MESH:
  855.         onWidget = menuItems[MM_SHAPE_QUAD_MESH].widget;
  856.         break;
  857.     case GeneralizedCylinder::CUBIC_SPLINE_SURFACE:
  858.         onWidget = menuItems[MM_SHAPE_CUBIC_SPLINE].widget;
  859.         break;
  860.     case GeneralizedCylinder::CUBIC_TO_EDGE_SURFACE:
  861.         onWidget = menuItems[MM_SHAPE_CUBIC_TO_EDGE].widget;
  862.         break;
  863.     case GeneralizedCylinder::BEZIER_SURFACE:
  864.         onWidget = menuItems[MM_SHAPE_BEZIER].widget;
  865.         break;
  866.     }
  867.     if (onWidget)
  868.     XmToggleButtonSetState( onWidget, TRUE, FALSE );
  869. }
  870.  
  871. void
  872. Interface::setManipTypeRadioButtons( const SoType &manipType )
  873. {
  874.     // First turn all radio buttons to FALSE...
  875.     XmToggleButtonSetState(menuItems[MM_MANIPS_HBOX].widget,FALSE,FALSE);
  876.     XmToggleButtonSetState(menuItems[MM_MANIPS_TRACKBALL].widget,FALSE,FALSE);
  877.     XmToggleButtonSetState(menuItems[MM_MANIPS_NONE].widget,FALSE,FALSE);
  878.  
  879.     // Set the appropriate radio button for manip type.
  880.     Widget onWidget = NULL;
  881.     if ( manipType.isDerivedFrom( SoHandleBoxManip::getClassTypeId() ) )
  882.     onWidget = menuItems[MM_MANIPS_HBOX].widget;
  883.     else if ( manipType.isDerivedFrom( SoTrackballManip::getClassTypeId()) )
  884.     onWidget = menuItems[MM_MANIPS_TRACKBALL].widget;
  885.     else
  886.     onWidget = menuItems[MM_MANIPS_NONE].widget;
  887.  
  888.     if (onWidget)
  889.     XmToggleButtonSetState( onWidget, TRUE, FALSE );
  890. }
  891.  
  892. ///////////////////////////////////////////////////////////////////////
  893. //
  894. // Callback registered on WorldInfo's selection node to invoke
  895. // setPrimarySelection() on the new selection.
  896. //
  897. void
  898. Interface::selectionCB( void *userData, SoPath *selectPath )
  899. {
  900.     // Return if pickFilter truncated path down to nothing.
  901.     if (selectPath->getLength() == 0)
  902.     return;
  903.  
  904.     Interface *myself = (Interface *) userData;
  905.  
  906.     SoNodeKitPath *nkPath = (SoNodeKitPath *) selectPath;
  907.     GeneralizedCylinder *g = (GeneralizedCylinder *) nkPath->getTail();
  908.  
  909.     myself->setPrimarySelection( g );
  910. }
  911.  
  912. ///////////////////////////////////////////////////////////////////////
  913. //
  914. // Create the top menu bar and the associated menus
  915. //
  916. Widget
  917. Interface::build( Widget parentWidget )
  918. {
  919.     mgrWidget = parentWidget;
  920.     if (mgrWidget == NULL)
  921.     fprintf(stderr, "Error. NULL passed to Interface::build\n");
  922.  
  923.     menuItems = new NoodleMenuItem[MM_MENU_NUM];
  924.     for (int i=0; i<MM_MENU_NUM; i++) {
  925.     menuItems[i].id = i;
  926.     menuItems[i].widget = NULL;
  927.     menuItems[i].ownerInterface = this;
  928.     }
  929.  
  930.     // 
  931.     // Create the topbar menu
  932.     //
  933.     Widget menuWidget = XmCreateMenuBar(mgrWidget, "menuBar", NULL, 0);
  934.  
  935.     Arg popupargs[4];
  936.     int popupn = 0;
  937. #ifdef MENUS_IN_POPUP
  938.     SoXt::getPopupArgs(XtDisplay(menuWidget), NULL, popupargs, &popupn);
  939. #endif
  940.  
  941.     int itemCount = XtNumber(pulldownData);
  942.     WidgetList buttons = (WidgetList) XtMalloc(itemCount * sizeof(Widget));
  943.     Widget popupWidget = NULL;
  944.  
  945.     
  946.     Arg args[12];
  947.     int n;
  948.     for (i=0; i<itemCount; i++) {
  949.     //
  950.         // Make Topbar menu button
  951.     //
  952.         Widget subMenu = 
  953.         XmCreatePulldownMenu(menuWidget, NULL, popupargs, popupn);
  954.         XtSetArg(args[0], XmNtearOffModel, XmTEAR_OFF_ENABLED);
  955.         XtSetValues(subMenu, args, 1);
  956.  
  957.         // We only need one widget for loading the proper popup colormap
  958.         if (! popupWidget)
  959.             popupWidget = subMenu;
  960.  
  961.         int id = pulldownData[i].id;
  962.         menuItems[id].widget = subMenu;
  963.  
  964.         XtSetArg(args[0], XmNsubMenuId, subMenu);
  965.         buttons[i] = XtCreateWidget(pulldownData[i].name,
  966.                     xmCascadeButtonGadgetClass, menuWidget, args, 1);
  967.  
  968.     //
  969.         // Make subMenu buttons
  970.     //
  971.         int subItemCount = pulldownData[i].subItemCount;
  972.         WidgetList subButtons = 
  973.         (WidgetList) XtMalloc(subItemCount * sizeof(Widget));
  974.  
  975.         for (int j=0; j<subItemCount; j++) {
  976.             if (pulldownData[i].subMenu[j].buttonType == MM_SEPARATOR) {
  977.                 subButtons[j] = XtCreateWidget(
  978.             NULL, xmSeparatorGadgetClass, subMenu, NULL, 0);
  979.           }
  980.             else {
  981.         String callbackReason;
  982.  
  983.                 switch (pulldownData[i].subMenu[j].buttonType) {
  984.                     case MM_PUSH_BUTTON:
  985.                         widgetClass = xmPushButtonGadgetClass;
  986.                         callbackReason = XmNactivateCallback;
  987.                         n = 0;
  988.                         break;
  989.                     case MM_TOGGLE_BUTTON:
  990.                         widgetClass = xmToggleButtonGadgetClass;
  991.                         callbackReason = XmNvalueChangedCallback;
  992.                         n = 0;
  993.                         break;
  994.                     case MM_RADIO_BUTTON:
  995.                         widgetClass = xmToggleButtonGadgetClass;
  996.                         callbackReason = XmNvalueChangedCallback;
  997.                         XtSetArg(args[0], XmNindicatorType, XmONE_OF_MANY);
  998.                         n = 1;
  999.                         break;
  1000.                     case MM_SEPARATOR:
  1001.             n = 0;
  1002.             fprintf(stderr, 
  1003.                 "Programming Error in Interface::build\n");
  1004.             break;
  1005.                     default:
  1006.                         fprintf(stderr, 
  1007.                 "noodle INTERNAL ERROR: bad buttonType\n");
  1008.                         break;
  1009.                 }
  1010.  
  1011.         //
  1012.                 // Check for keyboard accelerator
  1013.         //
  1014.                 char *accel = pulldownData[i].subMenu[j].accelerator;
  1015.                 char *accelText = pulldownData[i].subMenu[j].accelText;
  1016.                 XmString xmstr = NULL;
  1017.                 if (accel != NULL) {
  1018.                     XtSetArg(args[n], XmNaccelerator, accel); n++;
  1019.  
  1020.                     if (accelText != NULL) {
  1021.                         xmstr = XmStringCreate(accelText,
  1022.                                          XmSTRING_DEFAULT_CHARSET);
  1023.                         XtSetArg(args[n], XmNacceleratorText, xmstr); n++;
  1024.                     }
  1025.                 }
  1026.  
  1027.                 subButtons[j] = XtCreateWidget(
  1028.                     pulldownData[i].subMenu[j].name,
  1029.                                 widgetClass, subMenu, args, n);
  1030.                 if (xmstr != NULL)
  1031.                     XmStringFree(xmstr);
  1032.                 id = pulldownData[i].subMenu[j].id;
  1033.                 menuItems[id].widget = subButtons[j];
  1034.                 XtAddCallback(subButtons[j], callbackReason,
  1035.                     (XtCallbackProc)Interface::processTopbarEvent,
  1036.                     (XtPointer) &menuItems[id]);
  1037.  
  1038.         // If a toggle, set the starting state:
  1039.                 if (pulldownData[i].subMenu[j].buttonType == MM_TOGGLE_BUTTON ||
  1040.                     pulldownData[i].subMenu[j].buttonType == MM_RADIO_BUTTON){
  1041.             SbBool isOn;
  1042.             isOn = pulldownData[i].subMenu[j].isOn;
  1043.  
  1044.             XmToggleButtonGadgetSetState(subButtons[j], isOn, FALSE);
  1045.         }
  1046.             }
  1047.         }
  1048.         XtManageChildren(subButtons, subItemCount);
  1049.         XtFree((char *)subButtons);
  1050.     }
  1051.     XtManageChildren(buttons, itemCount);
  1052.     XtFree((char *)buttons);
  1053.  
  1054.     //
  1055.     // Layout the menu bar
  1056.     //
  1057.     n = 0;
  1058.     XtSetArg(args[n], XmNtopAttachment,   XmATTACH_FORM); n++;
  1059.     XtSetArg(args[n], XmNleftAttachment,  XmATTACH_FORM); n++;
  1060.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  1061.     XtSetValues(menuWidget, args, n);
  1062.     XtManageChild(menuWidget);
  1063.  
  1064.     return (menuWidget);
  1065. }
  1066.